/**
 * turn.js 4th release
 * turnjs.com
 * turnjs.com/license.txt
 *
 * Copyright (C) 2012 Emmanuel Garcia
 * All rights reserved
 **/

(function($) {

  'use strict';

  var has3d,

      hasRot,

      vendor = '',

      version = '4.1.0',

      PI = Math.PI,

      A90 = PI/2,

      isTouch = 'ontouchstart' in window,

      mouseEvents = (isTouch) ?
          {
            down: 'touchstart',
            move: 'touchmove',
            up: 'touchend',
            over: 'touchstart',
            out: 'touchend'
          }
          :
          {
            down: 'mousedown',
            move: 'mousemove',
            up: 'mouseup',
            over: 'mouseover',
            out: 'mouseout'
          },

      // Contansts used for each corner
      //   | tl * tr |
      // l | *     * | r
      //   | bl * br |

      corners = {
        backward: ['bl', 'tl'],
        forward: ['br', 'tr'],
        all: ['tl', 'bl', 'tr', 'br', 'l', 'r']
      },

      // Display values

      displays = ['single', 'double'],

      // Direction values

      directions = ['ltr', 'rtl'],

      // Default options

      turnOptions = {

        // Enables hardware acceleration

        acceleration: true,

        // Display

        display: 'double',

        // Duration of transition in milliseconds

        duration: 600,

        // First page

        page: 1,

        // Enables gradients

        gradients: true,

        // Corners used when turning the page

        turnCorners: 'bl,br',

        // Events

        when: null
      },

      flipOptions = {

        // Size of the active zone of each corner

        cornerSize: 100

      },

      // Number of pages in the DOM, minimum value: 6

      pagesInDOM = 6,


      turnMethods = {

        // Singleton constructor
        // $('#selector').turn([options]);

        init: function(options) {

          // Define constants

          has3d = 'WebKitCSSMatrix' in window || 'MozPerspective' in document.body.style;
          hasRot = rotationAvailable();
          vendor = getPrefix();

          var i, that = this, pageNum = 0, data = this.data(), ch = this.children();

          // Set initial configuration

          options = $.extend({
            width: this.width(),
            height: this.height(),
            direction: this.attr('dir') || this.css('direction') || 'ltr'
          }, turnOptions, options);

          data.opts = options;
          data.pageObjs = {};
          data.pages = {};
          data.pageWrap = {};
          data.pageZoom = {};
          data.pagePlace = {};
          data.pageMv = [];
          data.zoom = 1;
          data.totalPages = options.pages || 0;
          data.eventHandlers = {
            touchStart: $.proxy(turnMethods._touchStart, this),
            touchMove: $.proxy(turnMethods._touchMove, this),
            touchEnd: $.proxy(turnMethods._touchEnd, this),
            start: $.proxy(turnMethods._eventStart, this)
          };



          // Add event listeners

          if (options.when)
            for (i in options.when)
              if (has(i, options.when))
                this.bind(i, options.when[i]);

          // Set the css

          this.css({position: 'relative', width: options.width, height: options.height});

          // Set the initial display

          this.turn('display', options.display);

          // Set the direction

          if (options.direction!=='')
            this.turn('direction', options.direction);

          // Prevent blue screen problems of switching to hardware acceleration mode
          // By forcing hardware acceleration for ever

          if (has3d && !isTouch && options.acceleration)
            this.transform(translate(0, 0, true));

          // Add pages from the DOM

          for (i = 0; i<ch.length; i++) {
            if ($(ch[i]).attr('ignore')!='1') {
              this.turn('addPage', ch[i], ++pageNum);
            }
          }

          // Event listeners

          $(this).bind(mouseEvents.down, data.eventHandlers.touchStart).
          bind('end', turnMethods._eventEnd).
          bind('pressed', turnMethods._eventPressed).
          bind('released', turnMethods._eventReleased).
          bind('flip', turnMethods._flip);

          $(this).parent().bind('start', data.eventHandlers.start);

          $(document).bind(mouseEvents.move, data.eventHandlers.touchMove).
          bind(mouseEvents.up, data.eventHandlers.touchEnd);

          // Set the initial page

          this.turn('page', options.page);

          // This flipbook is ready

          data.done = true;

          return this;
        },

        // Adds a page from external data

        addPage: function(element, page) {

          var currentPage,
              className,
              incPages = false,
              data = this.data(),
              lastPage = data.totalPages+1;

          if (data.destroying)
            return false;

          // Read the page number from the className of `element` - format: p[0-9]+

          if ((currentPage = /\bp([0-9]+)\b/.exec($(element).attr('class'))))
            page = parseInt(currentPage[1], 10);

          if (page) {

            if (page==lastPage)
              incPages = true;
            else if (page>lastPage)
              throw turnError('Page "'+page+'" cannot be inserted');

          } else {

            page = lastPage;
            incPages = true;

          }

          if (page>=1 && page<=lastPage) {

            if (data.display=='double')
              className = (page%2) ? ' odd' : ' even';
            else
              className = '';

            // Stop animations
            if (data.done)
              this.turn('stop');

            // Move pages if it's necessary
            if (page in data.pageObjs)
              turnMethods._movePages.call(this, page, 1);

            // Increase the number of pages
            if (incPages)
              data.totalPages = lastPage;

            // Add element
            data.pageObjs[page] = $(element).
            css({'float': 'left'}).
            addClass('page p' + page + className);

            if (!hasHardPage() &&  data.pageObjs[page].hasClass('hard')) {
              data.pageObjs[page].removeClass('hard');
            }

            // Add page
            turnMethods._addPage.call(this, page);

            // Remove pages out of range
            turnMethods._removeFromDOM.call(this);
          }

          return this;
        },

        // Adds a page

        _addPage: function(page) {

          var data = this.data(),
              element = data.pageObjs[page];

          if (element)
            if (turnMethods._necessPage.call(this, page)) {

              if (!data.pageWrap[page]) {

                // Wrapper
                data.pageWrap[page] = $('<div/>',
                    {'class': 'page-wrapper',
                      page: page,
                      css: {position: 'absolute',
                        overflow: 'hidden'}});

                // Append to this flipbook
                this.append(data.pageWrap[page]);

                if (!data.pagePlace[page]) {

                  data.pagePlace[page] = page;
                  // Move `pageObjs[page]` to wrapper
                  data.pageObjs[page].appendTo(data.pageWrap[page]);

                }

                // Set the size of the page
                var prop = turnMethods._pageSize.call(this, page, true);
                element.css({width: prop.width, height: prop.height});
                data.pageWrap[page].css(prop);

              }

              if (data.pagePlace[page] == page) {

                // If the page isn't in another place, create the flip effect
                turnMethods._makeFlip.call(this, page);

              }

            } else {

              // Place
              data.pagePlace[page] = 0;

              // Remove element from the DOM
              if (data.pageObjs[page])
                data.pageObjs[page].remove();

            }

        },

        // Checks if a page is in memory

        hasPage: function(page) {

          return has(page, this.data().pageObjs);

        },

        // Centers the flipbook

        center: function(page) {

          var data = this.data(),
              size = $(this).turn('size'),
              left = 0;

          if (!data.noCenter) {
            if (data.display=='double') {
              var view = this.turn('view', page || data.tpage || data.page);

              if (data.direction=='ltr') {
                if (!view[0])
                  left -= size.width/4;
                else if (!view[1])
                  left += size.width/4;
              } else {
                if (!view[0])
                  left += size.width/4;
                else if (!view[1])
                  left -= size.width/4;
              }

            }

            $(this).css({marginLeft: left});
          }

          return this;

        },

        // Destroys the flipbook

        destroy: function () {

          var page,
              flipbook = this,
              data = this.data(),
              events = [
                'end', 'first', 'flip', 'last', 'pressed',
                'released', 'start', 'turning', 'turned',
                'zooming', 'missing'];

          if (trigger('destroying', this)=='prevented')
            return;

          data.destroying = true;

          $.each(events, function(index, eventName) {
            flipbook.unbind(eventName);
          });

          this.parent().unbind('start', data.eventHandlers.start);

          $(document).unbind(mouseEvents.move, data.eventHandlers.touchMove).
          unbind(mouseEvents.up, data.eventHandlers.touchEnd);

          while (data.totalPages!==0) {
            this.turn('removePage', data.totalPages);
          }

          if (data.fparent)
            data.fparent.remove();

          if (data.shadow)
            data.shadow.remove();

          this.removeData();
          data = null;

          return this;

        },

        // Checks if this element is a flipbook

        is: function() {

          return typeof(this.data().pages)=='object';

        },

        // Sets and gets the zoom value

        zoom: function(newZoom) {

          var data = this.data();

          if (typeof(newZoom)=='number') {

            if (newZoom<0.001 || newZoom>100)
              throw turnError(newZoom+ ' is not a value for zoom');

            if (trigger('zooming', this, [newZoom, data.zoom])=='prevented')
              return this;

            var size = this.turn('size'),
                currentView = this.turn('view'),
                iz = 1/data.zoom,
                newWidth = Math.round(size.width * iz * newZoom),
                newHeight = Math.round(size.height * iz * newZoom);

            data.zoom = newZoom;

            $(this).turn('stop').
            turn('size', newWidth, newHeight);
            /*.
            css({marginTop: size.height * iz / 2 - newHeight / 2});*/

            if (data.opts.autoCenter)
              this.turn('center');
            /*else
              $(this).css({marginLeft: size.width * iz / 2 - newWidth / 2});*/

            turnMethods._updateShadow.call(this);

            for (var i = 0; i<currentView.length; i++) {
              if (currentView[i] && data.pageZoom[currentView[i]]!=data.zoom) {

                this.trigger('zoomed',[
                  currentView[i],
                  currentView,
                  data.pageZoom[currentView[i]],
                  data.zoom]);

                data.pageZoom[currentView[i]] = data.zoom;
              }
            }

            return this;

          } else
            return data.zoom;

        },

        // Gets the size of a page

        _pageSize: function(page, position) {

          var data = this.data(),
              prop = {};

          if (data.display=='single') {

            prop.width = this.width();
            prop.height = this.height();

            if (position) {
              prop.top = 0;
              prop.left = 0;
              prop.right = 'auto';
            }

          } else {

            var pageWidth = this.width()/2,
                pageHeight = this.height();

            if (data.pageObjs[page].hasClass('own-size')) {
              prop.width = data.pageObjs[page].width();
              prop.height = data.pageObjs[page].height();
            } else {
              prop.width = pageWidth;
              prop.height = pageHeight;
            }

            if (position) {
              var odd = page%2;
              prop.top = (pageHeight-prop.height)/2;

              if (data.direction=='ltr') {

                prop[(odd) ? 'right' : 'left'] = pageWidth-prop.width;
                prop[(odd) ? 'left' : 'right'] = 'auto';

              } else {

                prop[(odd) ? 'left' : 'right'] = pageWidth-prop.width;
                prop[(odd) ? 'right' : 'left'] = 'auto';

              }

            }
          }

          return prop;

        },

        // Prepares the flip effect for a page

        _makeFlip: function(page) {

          var data = this.data();

          if (!data.pages[page] && data.pagePlace[page]==page) {

            var single = data.display=='single',
                odd = page%2;

            data.pages[page] = data.pageObjs[page].
            css(turnMethods._pageSize.call(this, page)).
            flip({
              page: page,
              next: (odd || single) ? page+1 : page-1,
              turn: this
            }).
            flip('disable', data.disabled);

            // Issue about z-index
            turnMethods._setPageLoc.call(this, page);

            data.pageZoom[page] = data.zoom;

          }

          return data.pages[page];
        },

        // Makes pages within a range

        _makeRange: function() {

          var page, range,
              data = this.data();

          if (data.totalPages<1)
            return;

          range = this.turn('range');

          for (page = range[0]; page<=range[1]; page++)
            turnMethods._addPage.call(this, page);

        },

        // Returns a range of pages that should be in the DOM
        // Example:
        // - page in the current view, return true
        // * page is in the range, return true
        // Otherwise, return false
        //
        // 1 2-3 4-5 6-7 8-9 10-11 12-13
        //   **  **  --   **  **

        range: function(page) {

          var remainingPages, left, right, view,
              data = this.data();

          page = page || data.tpage || data.page || 1;
          view = turnMethods._view.call(this, page);

          if (page<1 || page>data.totalPages)
            throw turnError('"'+page+'" is not a valid page');


          view[1] = view[1] || view[0];

          if (view[0]>=1 && view[1]<=data.totalPages) {

            remainingPages = Math.floor((pagesInDOM-2)/2);

            if (data.totalPages-view[1] > view[0]) {
              left = Math.min(view[0]-1, remainingPages);
              right = 2*remainingPages-left;
            } else {
              right = Math.min(data.totalPages-view[1], remainingPages);
              left = 2*remainingPages-right;
            }

          } else {
            left = pagesInDOM-1;
            right = pagesInDOM-1;
          }

          return [Math.max(1, view[0]-left),
            Math.min(data.totalPages, view[1]+right)];

        },

        // Detects if a page is within the range of `pagesInDOM` from the current view

        _necessPage: function(page) {

          if (page===0)
            return true;

          var range = this.turn('range');

          return this.data().pageObjs[page].hasClass('fixed') ||
              (page>=range[0] && page<=range[1]);

        },

        // Releases memory by removing pages from the DOM

        _removeFromDOM: function() {

          var page, data = this.data();

          for (page in data.pageWrap)
            if (has(page, data.pageWrap) &&
                !turnMethods._necessPage.call(this, page))
              turnMethods._removePageFromDOM.call(this, page);

        },

        // Removes a page from DOM and its internal references

        _removePageFromDOM: function(page) {

          var data = this.data();

          if (data.pages[page]) {
            var dd = data.pages[page].data();

            flipMethods._moveFoldingPage.call(data.pages[page], false);

            if (dd.f && dd.f.fwrapper)
              dd.f.fwrapper.remove();

            data.pages[page].removeData();
            data.pages[page].remove();
            delete data.pages[page];
          }

          if (data.pageObjs[page])
            data.pageObjs[page].remove();

          if (data.pageWrap[page]) {
            data.pageWrap[page].remove();
            delete data.pageWrap[page];
          }

          turnMethods._removeMv.call(this, page);

          delete data.pagePlace[page];
          delete data.pageZoom[page];

        },

        // Removes a page

        removePage: function(page) {

          var data = this.data();

          // Delete all the pages
          if (page=='*') {

            while (data.totalPages!==0) {
              this.turn('removePage', data.totalPages);
            }

          } else {

            if (page<1 || page>data.totalPages)
              throw turnError('The page '+ page + ' doesn\'t exist');

            if (data.pageObjs[page]) {

              // Stop animations
              this.turn('stop');

              // Remove `page`
              turnMethods._removePageFromDOM.call(this, page);

              delete data.pageObjs[page];

            }

            // Move the pages
            turnMethods._movePages.call(this, page, -1);

            // Resize the size of this flipbook
            data.totalPages = data.totalPages-1;

            // Check the current view

            if (data.page>data.totalPages) {

              data.page = null;
              turnMethods._fitPage.call(this, data.totalPages);

            } else {

              turnMethods._makeRange.call(this);
              this.turn('update');

            }
          }

          return this;

        },

        // Moves pages

        _movePages: function(from, change) {

          var page,
              that = this,
              data = this.data(),
              single = data.display=='single',
              move = function(page) {

                var next = page + change,
                    odd = next%2,
                    className = (odd) ? ' odd ' : ' even ';

                if (data.pageObjs[page])
                  data.pageObjs[next] = data.pageObjs[page].
                  removeClass('p' + page + ' odd even').
                  addClass('p' + next + className);

                if (data.pagePlace[page] && data.pageWrap[page]) {

                  data.pagePlace[next] = next;

                  if (data.pageObjs[next].hasClass('fixed'))
                    data.pageWrap[next] = data.pageWrap[page].
                    attr('page', next);
                  else
                    data.pageWrap[next] = data.pageWrap[page].
                    css(turnMethods._pageSize.call(that, next, true)).
                    attr('page', next);

                  if (data.pages[page])
                    data.pages[next] = data.pages[page].
                    flip('options', {
                      page: next,
                      next: (single || odd) ? next+1 : next-1
                    });

                  if (change) {
                    delete data.pages[page];
                    delete data.pagePlace[page];
                    delete data.pageZoom[page];
                    delete data.pageObjs[page];
                    delete data.pageWrap[page];
                  }

                }

              };

          if (change>0)
            for (page=data.totalPages; page>=from; page--)
              move(page);
          else
            for (page=from; page<=data.totalPages; page++)
              move(page);

        },

        // Sets or Gets the display mode

        display: function(display) {

          var data = this.data(),
              currentDisplay = data.display;

          if (display===undefined) {

            return currentDisplay;

          } else {

            if ($.inArray(display, displays)==-1)
              throw turnError('"'+display + '" is not a value for display');

            switch(display) {
              case 'single':

                // Create a temporal page to use as folded page

                if (!data.pageObjs[0]) {
                  this.turn('stop').
                  css({'overflow': 'hidden'});

                  data.pageObjs[0] = $('<div />',
                      {'class': 'page p-temporal'}).
                  css({width: this.width(), height: this.height()}).
                  appendTo(this);
                }

                this.addClass('shadow');

                break;
              case 'double':

                // Remove the temporal page

                if (data.pageObjs[0]) {
                  this.turn('stop').css({'overflow': ''});
                  data.pageObjs[0].remove();
                  delete data.pageObjs[0];
                }

                this.removeClass('shadow');

                break;
            }


            data.display = display;

            if (currentDisplay) {
              var size = this.turn('size');
              turnMethods._movePages.call(this, 1, 0);
              this.turn('size', size.width, size.height).
              turn('update');
            }

            return this;

          }

        },

        // Gets and sets the direction of the flipbook

        direction: function(dir) {

          var data = this.data();

          if (dir===undefined) {

            return data.direction;

          } else {

            dir = dir.toLowerCase();

            if ($.inArray(dir, directions)==-1)
              throw turnError('"' + dir + '" is not a value for direction');

            if (dir=='rtl') {
              $(this).attr('dir', 'ltr').
              css({direction: 'ltr'});
            }

            data.direction = dir;

            if (data.done)
              this.turn('size', $(this).width(), $(this).height());

            return this;
          }

        },

        // Detects animation

        animating: function() {

          return this.data().pageMv.length>0;

        },

        // Gets the current activated corner

        corner: function() {

          var corner,
              page,
              data = this.data();

          for (page in data.pages) {
            if (has(page, data.pages))
              if ((corner = data.pages[page].flip('corner'))) {
                return corner;
              }
          }

          return false;
        },

        // Gets the data stored in the flipbook

        data: function() {

          return this.data();

        },

        // Disables and enables the effect

        disable: function(disable) {

          var page,
              data = this.data(),
              view = this.turn('view');

          data.disabled = disable===undefined || disable===true;

          for (page in data.pages) {
            if (has(page, data.pages))
              data.pages[page].flip('disable',
                  (data.disabled) ? true : $.inArray(parseInt(page, 10), view)==-1);
          }

          return this;

        },

        // Disables and enables the effect

        disabled: function(disable) {

          if (disable===undefined) {
            return this.data().disabled===true;
          } else {
            return this.turn('disable', disable);
          }

        },

        // Gets and sets the size

        size: function(width, height) {

          if (width===undefined || height===undefined) {

            return {width: this.width(), height: this.height()};

          } else {

            this.turn('stop');

            var page, prop,
                data = this.data(),
                pageWidth = (data.display=='double') ? width/2 : width;

            this.css({width: width, height: height});

            if (data.pageObjs[0])
              data.pageObjs[0].css({width: pageWidth, height: height});

            for (page in data.pageWrap) {
              if (!has(page, data.pageWrap)) continue;

              prop = turnMethods._pageSize.call(this, page, true);

              data.pageObjs[page].css({width: prop.width, height: prop.height});
              data.pageWrap[page].css(prop);

              if (data.pages[page])
                data.pages[page].css({width: prop.width, height: prop.height});
            }

            this.turn('resize');

            return this;

          }
        },

        // Resizes each page

        resize: function() {

          var page, data = this.data();

          if (data.pages[0]) {
            data.pageWrap[0].css({left: -this.width()});
            data.pages[0].flip('resize', true);
          }

          for (page = 1; page <= data.totalPages; page++)
            if (data.pages[page])
              data.pages[page].flip('resize', true);

          turnMethods._updateShadow.call(this);

          if (data.opts.autoCenter)
            this.turn('center');

        },

        // Removes an animation from the cache

        _removeMv: function(page) {

          var i, data = this.data();

          for (i=0; i<data.pageMv.length; i++)
            if (data.pageMv[i]==page) {
              data.pageMv.splice(i, 1);
              return true;
            }

          return false;

        },

        // Adds an animation to the cache

        _addMv: function(page) {

          var data = this.data();

          turnMethods._removeMv.call(this, page);
          data.pageMv.push(page);

        },

        // Gets indexes for a view

        _view: function(page) {

          var data = this.data();

          page = page || data.page;

          if (data.display=='double')
            return (page%2) ? [page-1, page] : [page, page+1];
          else
            return [page];

        },

        // Gets a view

        view: function(page) {

          var data = this.data(),
              view = turnMethods._view.call(this, page);

          if (data.display=='double')
            return [(view[0]>0) ? view[0] : 0,
              (view[1]<=data.totalPages) ? view[1] : 0];
          else
            return [(view[0]>0 && view[0]<=data.totalPages) ? view[0] : 0];

        },

        // Stops animations

        stop: function(ignore, animate) {

          if (this.turn('animating')) {

            var i, opts, page,
                data = this.data();

            if (data.tpage) {
              data.page = data.tpage;
              delete data['tpage'];
            }

            for (i = 0; i<data.pageMv.length; i++) {

              if (!data.pageMv[i] || data.pageMv[i]===ignore)
                continue;

              page = data.pages[data.pageMv[i]];
              opts = page.data().f.opts;

              page.flip('hideFoldedPage', animate);

              if (!animate)
                flipMethods._moveFoldingPage.call(page, false);

              if (opts.force) {
                opts.next = (opts.page%2===0) ? opts.page-1 : opts.page+1;
                delete opts['force'];
              }

            }
          }

          this.turn('update');

          return this;
        },

        // Gets and sets the number of pages

        pages: function(pages) {

          var data = this.data();

          if (pages) {

            if (pages<data.totalPages) {

              for (var page = data.totalPages; page>pages; page--)
                this.turn('removePage', page);

            }

            data.totalPages = pages;
            turnMethods._fitPage.call(this, data.page);

            return this;

          } else
            return data.totalPages;

        },

        // Checks missing pages

        _missing : function(page) {

          var data = this.data();

          if (data.totalPages<1)
            return;

          var p,
              range = this.turn('range', page),
              missing = [];

          for (p = range[0]; p<=range[1]; p++) {
            if (!data.pageObjs[p])
              missing.push(p);
          }

          if (missing.length>0)
            this.trigger('missing', [missing]);

        },

        // Sets a page without effect

        _fitPage: function(page) {

          var data = this.data(),
              newView = this.turn('view', page);

          turnMethods._missing.call(this, page);

          if (!data.pageObjs[page])
            return;

          data.page = page;

          this.turn('stop');

          for (var i = 0; i<newView.length; i++) {

            if (newView[i] && data.pageZoom[newView[i]]!=data.zoom) {

              this.trigger('zoomed',[
                newView[i],
                newView,
                data.pageZoom[newView[i]],
                data.zoom]);

              data.pageZoom[newView[i]] = data.zoom;

            }
          }

          turnMethods._removeFromDOM.call(this);
          turnMethods._makeRange.call(this);
          turnMethods._updateShadow.call(this);
          this.trigger('turned', [page, newView]);
          this.turn('update');

          if (data.opts.autoCenter)
            this.turn('center');

        },

        // Turns the page

        _turnPage: function(page) {

          var current,
              next,
              data = this.data(),
              place = data.pagePlace[page],
              view = this.turn('view'),
              newView = this.turn('view', page);


          if (data.page!=page) {

            var currentPage = data.page;

            if (trigger('turning', this, [page, newView])=='prevented') {

              if (currentPage==data.page && $.inArray(place, data.pageMv)!=-1)
                data.pages[place].flip('hideFoldedPage', true);

              return;

            }

            if ($.inArray(1, newView)!=-1)
              this.trigger('first');
            if ($.inArray(data.totalPages, newView)!=-1)
              this.trigger('last');

          }

          if (data.display=='single') {
            current = view[0];
            next = newView[0];
          } else if (view[1] && page>view[1]) {
            current = view[1];
            next = newView[0];
          } else if (view[0] && page<view[0]) {
            current = view[0];
            next = newView[1];
          }

          var optsCorners = data.opts.turnCorners.split(','),
              flipData = data.pages[current].data().f,
              opts = flipData.opts,
              actualPoint = flipData.point;

          turnMethods._missing.call(this, page);

          if (!data.pageObjs[page])
            return;

          this.turn('stop');

          data.page = page;

          turnMethods._makeRange.call(this);

          data.tpage = next;

          if (opts.next!=next) {
            opts.next = next;
            opts.force = true;
          }

          this.turn('update');

          flipData.point = actualPoint;

          if (flipData.effect=='hard')
            if (data.direction=='ltr')
              data.pages[current].flip('turnPage',
                  (page>current) ? 'r' : 'l');
            else
              data.pages[current].flip('turnPage',
                  (page>current) ? 'l' : 'r');
          else {
            if (data.direction=='ltr')
              data.pages[current].flip('turnPage',
                  optsCorners[(page>current) ? 1 : 0]);
            else
              data.pages[current].flip('turnPage',
                  optsCorners[(page>current) ? 0 : 1]);
          }

        },

        // Gets and sets a page

        page: function(page) {

          var data = this.data();

          if (page===undefined) {

            return data.page;

          } else {

            if (!data.disabled && !data.destroying) {

              page = parseInt(page, 10);

              if (page>0 && page<=data.totalPages) {

                if (page!=data.page) {
                  if (!data.done || $.inArray(page, this.turn('view'))!=-1)
                    turnMethods._fitPage.call(this, page);
                  else
                    turnMethods._turnPage.call(this, page);
                }

                return this;

              } else {

                throw turnError('The page ' + page + ' does not exist');

              }

            }

          }

        },

        // Turns to the next view

        next: function() {

          return this.turn('page', Math.min(this.data().totalPages,
              turnMethods._view.call(this, this.data().page).pop() + 1));

        },

        // Turns to the previous view

        previous: function() {

          return this.turn('page', Math.max(1,
              turnMethods._view.call(this, this.data().page).shift() - 1));

        },

        // Shows a peeling corner

        peel: function(corner, animate) {

          var data = this.data(),
              view = this.turn('view');

          animate = (animate===undefined) ? true : animate===true;

          if (corner===false) {

            this.turn('stop', null, animate);

          } else {

            if (data.display=='single') {

              data.pages[data.page].flip('peel', corner, animate);

            } else {

              var page;

              if (data.direction=='ltr') {

                page = (corner.indexOf('l')!=-1) ? view[0] : view[1];

              } else {

                page = (corner.indexOf('l')!=-1) ? view[1] : view[0];

              }

              if (data.pages[page])
                data.pages[page].flip('peel', corner, animate);

            }
          }

          return this;

        },

        // Adds a motion to the internal list
        // This event is called in context of flip

        _addMotionPage: function() {

          var opts = $(this).data().f.opts,
              turn = opts.turn,
              dd = turn.data();

          turnMethods._addMv.call(turn, opts.page);

        },

        // This event is called in context of flip

        _eventStart: function(e, opts, corner) {

          var data = opts.turn.data(),
              actualZoom = data.pageZoom[opts.page];

          if (e.isDefaultPrevented()) {
            turnMethods._updateShadow.call(opts.turn);
            return;
          }

          if (actualZoom && actualZoom!=data.zoom) {

            opts.turn.trigger('zoomed',[
              opts.page,
              opts.turn.turn('view', opts.page),
              actualZoom,
              data.zoom]);

            data.pageZoom[opts.page] = data.zoom;

          }

          if (data.display=='single' && corner) {

            if ((corner.charAt(1)=='l' && data.direction=='ltr') ||
                (corner.charAt(1)=='r' && data.direction=='rtl'))
            {

              opts.next = (opts.next<opts.page) ? opts.next : opts.page-1;
              opts.force = true;

            } else {

              opts.next = (opts.next>opts.page) ? opts.next : opts.page+1;

            }

          }

          turnMethods._addMotionPage.call(e.target);
          turnMethods._updateShadow.call(opts.turn);
        },

        // This event is called in context of flip

        _eventEnd: function(e, opts, turned) {

          var that = $(e.target),
              data = that.data().f,
              turn = opts.turn,
              dd = turn.data();

          if (turned) {

            var tpage = dd.tpage || dd.page;

            if (tpage==opts.next || tpage==opts.page) {
              delete dd.tpage;

              turnMethods._fitPage.call(turn, tpage || opts.next, true);
            }

          } else {

            turnMethods._removeMv.call(turn, opts.page);
            turnMethods._updateShadow.call(turn);
            turn.turn('update');

          }

        },

        // This event is called in context of flip

        _eventPressed: function(e) {

          var page,
              data = $(e.target).data().f,
              turn = data.opts.turn,
              turnData = turn.data(),
              pages = turnData.pages;

          turnData.mouseAction = true;

          turn.turn('update');

          return data.time = new Date().getTime();

        },

        // This event is called in context of flip

        _eventReleased: function(e, point) {

          var outArea,
              page = $(e.target),
              data = page.data().f,
              turn = data.opts.turn,
              turnData = turn.data();

          if (turnData.display=='single') {
            outArea = (point.corner=='br' || point.corner=='tr') ?
                point.x<page.width()/2:
                point.x>page.width()/2;
          } else {
            outArea = point.x<0 || point.x>page.width();
          }

          if ((new Date()).getTime()-data.time<200 || outArea) {

            e.preventDefault();
            turnMethods._turnPage.call(turn, data.opts.next);

          }

          turnData.mouseAction = false;

        },

        // This event is called in context of flip

        _flip: function(e) {

          e.stopPropagation();

          var opts = $(e.target).data().f.opts;

          opts.turn.trigger('turn', [opts.next]);

          if (opts.turn.data().opts.autoCenter) {
            opts.turn.turn('center', opts.next);
          }

        },

        //
        _touchStart: function() {
          var data = this.data();
          for (var page in data.pages) {
            if (has(page, data.pages) &&
                flipMethods._eventStart.apply(data.pages[page], arguments)===false) {
              return false;
            }
          }
        },

        //
        _touchMove: function() {
          var data = this.data();
          for (var page in data.pages) {
            if (has(page, data.pages)) {
              flipMethods._eventMove.apply(data.pages[page], arguments);
            }
          }
        },

        //
        _touchEnd: function() {
          var data = this.data();
          for (var page in data.pages) {
            if (has(page, data.pages)) {
              flipMethods._eventEnd.apply(data.pages[page], arguments);
            }
          }
        },

        // Calculate the z-index value for pages during the animation

        calculateZ: function(mv) {

          var i, page, nextPage, placePage, dpage,
              that = this,
              data = this.data(),
              view = this.turn('view'),
              currentPage = view[0] || view[1],
              total = mv.length-1,
              r = {pageZ: {}, partZ: {}, pageV: {}},

              addView = function(page) {
                var view = that.turn('view', page);
                if (view[0]) r.pageV[view[0]] = true;
                if (view[1]) r.pageV[view[1]] = true;
              };

          for (i = 0; i<=total; i++) {
            page = mv[i];
            nextPage = data.pages[page].data().f.opts.next;
            placePage = data.pagePlace[page];
            addView(page);
            addView(nextPage);
            dpage = (data.pagePlace[nextPage]==nextPage) ? nextPage : page;
            r.pageZ[dpage] = data.totalPages - Math.abs(currentPage-dpage);
            r.partZ[placePage] = data.totalPages*2 -  total + i;
          }

          return r;
        },

        // Updates the z-index and display property of every page

        update: function() {

          var page,
              data = this.data();

          if (this.turn('animating') && data.pageMv[0]!==0) {

            // Update motion

            var p, apage, fixed,
                pos = this.turn('calculateZ', data.pageMv),
                corner = this.turn('corner'),
                actualView = this.turn('view'),
                newView = this.turn('view', data.tpage);

            for (page in data.pageWrap) {

              if (!has(page, data.pageWrap))
                continue;

              fixed = data.pageObjs[page].hasClass('fixed');

              data.pageWrap[page].css({
                display: (pos.pageV[page] || fixed) ? '' : 'none',
                zIndex:
                    (data.pageObjs[page].hasClass('hard') ?
                            pos.partZ[page]
                            :
                            pos.pageZ[page]
                    ) || (fixed ? -1 : 0)
              });

              if ((p = data.pages[page])) {

                p.flip('z', pos.partZ[page] || null);

                if (pos.pageV[page])
                  p.flip('resize');

                if (data.tpage) { // Is it turning the page to `tpage`?

                  p.flip('hover', false).
                  flip('disable',
                      $.inArray(parseInt(page, 10), data.pageMv)==-1 &&
                      page!=newView[0] &&
                      page!=newView[1]);

                } else {

                  p.flip('hover', corner===false).
                  flip('disable', page!=actualView[0] && page!=actualView[1]);

                }

              }

            }

          } else {

            // Update static pages

            for (page in data.pageWrap) {

              if (!has(page, data.pageWrap))
                continue;

              var pageLocation = turnMethods._setPageLoc.call(this, page);

              if (data.pages[page]) {
                data.pages[page].
                flip('disable', data.disabled || pageLocation!=1).
                flip('hover', true).
                flip('z', null);
              }
            }
          }

          return this;
        },

        // Updates the position and size of the flipbook's shadow

        _updateShadow: function() {

          var view, view2, shadow,
              data = this.data(),
              width = this.width(),
              height = this.height(),
              pageWidth = (data.display=='single') ? width : width/2;

          view = this.turn('view');

          if (!data.shadow) {
            data.shadow = $('<div />', {
              'class': 'shadow',
              'css': divAtt(0, 0, 0).css
            }).
            appendTo(this);
          }

          for (var i = 0; i<data.pageMv.length; i++) {
            if (!view[0] || !view[1])
              break;

            view = this.turn('view', data.pages[data.pageMv[i]].data().f.opts.next);
            view2 = this.turn('view', data.pageMv[i]);

            view[0] = view[0] && view2[0];
            view[1] = view[1] && view2[1];
          }

          if (!view[0]) shadow = (data.direction=='ltr') ? 1 : 2;
          else if (!view[1]) shadow = (data.direction=='ltr') ? 2 : 1;
          else shadow = 3;

          switch (shadow) {
            case 1:
              data.shadow.css({
                width: pageWidth,
                height: height,
                top: 0,
                left: pageWidth
              });
              break;
            case 2:
              data.shadow.css({
                width: pageWidth,
                height: height,
                top: 0,
                left: 0
              });
              break;
            case 3:
              data.shadow.css({
                width: width,
                height: height,
                top: 0,
                left: 0
              });
              break;
          }

        },

        // Sets the z-index and display property of a page
        // It depends on the current view

        _setPageLoc: function(page) {

          var data = this.data(),
              view = this.turn('view'),
              loc = 0;


          if (page==view[0] || page==view[1])
            loc = 1;
          else if (
              (data.display=='single' && page==view[0]+1) ||
              (data.display=='double' && page==view[0]-2 || page==view[1]+2)
          )
            loc = 2;

          if (!this.turn('animating'))
            switch (loc) {
              case 1:
                data.pageWrap[page].css(
                    {
                      zIndex: data.totalPages,
                      display: ''
                    });
                break;
              case 2:
                data.pageWrap[page].css(
                    {
                      zIndex: data.totalPages-1,
                      display: ''
                    });
                break;
              case 0:
                data.pageWrap[page].css(
                    {
                      zIndex: 0,
                      display: (data.pageObjs[page].hasClass('fixed')) ? '' : 'none'}
                );
                break;
            }

          return loc;
        },

        // Gets and sets the options

        options: function(options) {

          if (options===undefined) {

            return this.data().opts;

          } else {

            var data = this.data();

            // Set new values

            $.extend(data.opts, options);

            // Set pages

            if (options.pages)
              this.turn('pages', options.pages);

            // Set page

            if (options.page)
              this.turn('page', options.page);

            // Set display

            if (options.display)
              this.turn('display', options.display);

            // Set direction

            if (options.direction)
              this.turn('direction', options.direction);

            // Set size

            if (options.width && options.height)
              this.turn('size', options.width, options.height);

            // Add event listeners

            if (options.when)
              for (var eventName in options.when)
                if (has(eventName, options.when)) {
                  this.unbind(eventName).
                  bind(eventName, options.when[eventName]);
                }

            return this;
          }

        },

        // Gets the current version

        version: function() {

          return version;

        }
      },

// Methods and properties for the flip page effect

      flipMethods = {

        // Constructor

        init: function(opts) {

          this.data({f: {
              disabled: false,
              hover: false,
              effect: (this.hasClass('hard')) ? 'hard' : 'sheet'
            }});

          this.flip('options', opts);

          flipMethods._addPageWrapper.call(this);

          return this;
        },

        setData: function(d) {

          var data = this.data();

          data.f = $.extend(data.f, d);

          return this;
        },

        options: function(opts) {

          var data = this.data().f;

          if (opts) {
            flipMethods.setData.call(this,
                {opts: $.extend({}, data.opts || flipOptions, opts)});
            return this;
          } else
            return data.opts;

        },

        z: function(z) {

          var data = this.data().f;

          data.opts['z-index'] = z;

          if (data.fwrapper)
            data.fwrapper.css({
              zIndex: z || parseInt(data.parent.css('z-index'), 10) || 0
            });

          return this;
        },

        _cAllowed: function() {

          var data = this.data().f,
              page = data.opts.page,
              turnData = data.opts.turn.data(),
              odd = page%2;

          if (data.effect=='hard') {

            return (turnData.direction=='ltr') ?
                [(odd) ? 'r' : 'l'] :
                [(odd) ? 'l' : 'r'];

          } else {

            if (turnData.display=='single') {

              if (page==1)
                return (turnData.direction=='ltr') ?
                    corners['forward'] : corners['backward'];
              else if (page==turnData.totalPages)
                return (turnData.direction=='ltr') ?
                    corners['backward'] : corners['forward'];
              else
                return corners['all'];

            } else {

              return (turnData.direction=='ltr') ?
                  corners[(odd) ? 'forward' : 'backward']
                  :
                  corners[(odd) ? 'backward' : 'forward'];

            }

          }

        },

        _cornerActivated: function(p) {

          var data = this.data().f,
              width = this.width(),
              height = this.height(),
              point = {x: p.x, y: p.y, corner: ''},
              csz = data.opts.cornerSize;

          if (point.x<=0 || point.y<=0 || point.x>=width || point.y>=height)
            return false;

          var allowedCorners = flipMethods._cAllowed.call(this);

          switch (data.effect) {
            case 'hard':

              if (point.x>width-csz)
                point.corner = 'r';
              else if (point.x<csz)
                point.corner = 'l';
              else
                return false;

              break;

            case 'sheet':

              if (point.y<csz)
                point.corner+= 't';
              else if (point.y>=height-csz)
                point.corner+= 'b';
              else
                return false;

              if (point.x<=csz)
                point.corner+= 'l';
              else if (point.x>=width-csz)
                point.corner+= 'r';
              else
                return false;

              break;
          }

          return (!point.corner || $.inArray(point.corner, allowedCorners)==-1) ?
              false : point;

        },

        _isIArea: function(e) {

          var pos = this.data().f.parent.offset();

          e = (isTouch && e.originalEvent) ? e.originalEvent.touches[0] : e;

          return flipMethods._cornerActivated.call(this,
              {
                x: e.pageX-pos.left,
                y: e.pageY-pos.top
              });

        },

        _c: function(corner, opts) {

          opts = opts || 0;

          switch (corner) {
            case 'tl':
              return point2D(opts, opts);
            case 'tr':
              return point2D(this.width()-opts, opts);
            case 'bl':
              return point2D(opts, this.height()-opts);
            case 'br':
              return point2D(this.width()-opts, this.height()-opts);
            case 'l':
              return point2D(opts, 0);
            case 'r':
              return point2D(this.width()-opts, 0);
          }

        },

        _c2: function(corner) {

          switch (corner) {
            case 'tl':
              return point2D(this.width()*2, 0);
            case 'tr':
              return point2D(-this.width(), 0);
            case 'bl':
              return point2D(this.width()*2, this.height());
            case 'br':
              return point2D(-this.width(), this.height());
            case 'l':
              return point2D(this.width()*2, 0);
            case 'r':
              return point2D(-this.width(), 0);
          }

        },

        _foldingPage: function() {

          var data = this.data().f;

          if (!data)
            return;

          var opts = data.opts;

          if (opts.turn) {
            data = opts.turn.data();
            if (data.display == 'single')
              return (opts.next>1 || opts.page>1) ? data.pageObjs[0] : null;
            else
              return data.pageObjs[opts.next];
          }

        },

        _backGradient: function() {

          var data = this.data().f,
              turnData = data.opts.turn.data(),
              gradient =  turnData.opts.gradients && (turnData.display=='single' ||
                  (data.opts.page!=2 && data.opts.page!=turnData.totalPages-1));

          if (gradient && !data.bshadow)
            data.bshadow = $('<div/>', divAtt(0, 0, 1)).
            css({'position': '', width: this.width(), height: this.height()}).
            appendTo(data.parent);

          return gradient;

        },

        type: function () {

          return this.data().f.effect;

        },

        resize: function(full) {

          var data = this.data().f,
              turnData = data.opts.turn.data(),
              width = this.width(),
              height = this.height();

          switch (data.effect) {
            case 'hard':

              if (full) {
                data.wrapper.css({width: width, height: height});
                data.fpage.css({width: width, height: height});
                if (turnData.opts.gradients) {
                  data.ashadow.css({width: width, height: height});
                  data.bshadow.css({width: width, height: height});
                }
              }

              break;
            case 'sheet':

              if (full) {
                var size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));

                data.wrapper.css({width: size, height: size});
                data.fwrapper.css({width: size, height: size}).
                children(':first-child').
                css({width: width, height: height});

                data.fpage.css({width: width, height: height});

                if (turnData.opts.gradients)
                  data.ashadow.css({width: width, height: height});

                if (flipMethods._backGradient.call(this))
                  data.bshadow.css({width: width, height: height});
              }

              if (data.parent.is(':visible')) {
                var offset = findPos(data.parent[0]);

                data.fwrapper.css({top: offset.top,
                  left: offset.left});

                //if (data.opts.turn) {
                offset = findPos(data.opts.turn[0]);
                data.fparent.css({top: -offset.top, left: -offset.left});
                //}
              }

              this.flip('z', data.opts['z-index']);

              break;
          }

        },

        // Prepares the page by adding a general wrapper and another objects

        _addPageWrapper: function() {

          var att,
              data = this.data().f,
              turnData = data.opts.turn.data(),
              parent = this.parent();

          data.parent = parent;

          if (!data.wrapper)
            switch (data.effect) {
              case 'hard':

                var cssProperties = {};
                cssProperties[vendor + 'transform-style'] = 'preserve-3d';
                cssProperties[vendor + 'backface-visibility'] = 'hidden';

                data.wrapper = $('<div/>', divAtt(0, 0, 2)).
                css(cssProperties).
                appendTo(parent).
                prepend(this);

                data.fpage = $('<div/>', divAtt(0, 0, 1)).
                css(cssProperties).
                appendTo(parent);

                if (turnData.opts.gradients) {
                  data.ashadow = $('<div/>', divAtt(0, 0,  0)).
                  hide().
                  appendTo(parent);

                  data.bshadow = $('<div/>', divAtt(0, 0,  0));
                }

                break;
              case 'sheet':

                var width = this.width(),
                    height = this.height(),
                    size = Math.round(Math.sqrt(Math.pow(width, 2)+Math.pow(height, 2)));

                data.fparent = data.opts.turn.data().fparent;

                if (!data.fparent) {
                  var fparent = $('<div/>', {css: {'pointer-events': 'none'}}).hide();
                  fparent.data().flips = 0;
                  fparent.css(divAtt(0, 0, 'auto', 'visible').css).
                  appendTo(data.opts.turn);

                  data.opts.turn.data().fparent = fparent;
                  data.fparent = fparent;
                }

                this.css({position: 'absolute', top: 0, left: 0, bottom: 'auto', right: 'auto'});

                data.wrapper = $('<div/>', divAtt(0, 0, this.css('z-index'))).
                appendTo(parent).
                prepend(this);

                data.fwrapper = $('<div/>', divAtt(parent.offset().top, parent.offset().left)).
                hide().
                appendTo(data.fparent);

                data.fpage = $('<div/>', divAtt(0, 0, 0, 'visible')).
                css({cursor: 'default'}).
                appendTo(data.fwrapper);

                if (turnData.opts.gradients)
                  data.ashadow = $('<div/>', divAtt(0, 0,  1)).
                  appendTo(data.fpage);

                flipMethods.setData.call(this, data);

                break;
            }

          // Set size
          flipMethods.resize.call(this, true);

        },

        // Takes a 2P point from the screen and applies the transformation

        _fold: function(point) {

          var data = this.data().f,
              turnData = data.opts.turn.data(),
              o = flipMethods._c.call(this, point.corner),
              width = this.width(),
              height = this.height();

          switch (data.effect) {

            case 'hard':

              if (point.corner=='l')
                point.x = Math.min(Math.max(point.x, 0), width*2);
              else
                point.x = Math.max(Math.min(point.x, width), -width);

              var leftPos,
                  shadow,
                  gradientX,
                  fpageOrigin,
                  parentOrigin,
                  totalPages = turnData.totalPages,
                  zIndex = data.opts['z-index'] || totalPages,
                  parentCss = {'overflow': 'visible'},
                  relX = (o.x) ? (o.x - point.x)/width : point.x/width,
                  angle = relX * 90,
                  half = angle<90;

              switch (point.corner) {
                case 'l':

                  fpageOrigin =  '0% 50%';
                  parentOrigin =  '100% 50%';

                  if (half) {
                    leftPos = 0;
                    shadow = data.opts.next-1>0;
                    gradientX = 1;
                  } else {
                    leftPos = '100%';
                    shadow = data.opts.page+1<totalPages;
                    gradientX = 0;
                  }

                  break;
                case 'r':

                  fpageOrigin =  '100% 50%';
                  parentOrigin =  '0% 50%';
                  angle = -angle;
                  width = -width;

                  if (half) {
                    leftPos = 0;
                    shadow = data.opts.next+1<totalPages;
                    gradientX = 0;
                  } else {
                    leftPos = '-100%';
                    shadow = data.opts.page!=1;
                    gradientX = 1;
                  }

                  break;
              }

              parentCss[vendor+'perspective-origin'] = parentOrigin;

              data.wrapper.transform('rotateY('+angle+'deg)' +
                  'translate3d(0px, 0px, '+(this.attr('depth')||0)+'px)', parentOrigin);

              data.fpage.transform('translateX('+width+'px) rotateY('+(180+angle)+'deg)', fpageOrigin);

              data.parent.css(parentCss);

              if (half) {
                relX = -relX+1;
                data.wrapper.css({zIndex: zIndex+1});
                data.fpage.css({zIndex: zIndex});
              } else {
                relX = relX-1;
                data.wrapper.css({zIndex: zIndex});
                data.fpage.css({zIndex: zIndex+1});
              }

              if (turnData.opts.gradients) {
                if (shadow)
                  data.ashadow.css({
                    display: '',
                    left: leftPos,
                    backgroundColor: 'rgba(0,0,0,'+(0.5*relX)+')'
                  }).
                  transform('rotateY(0deg)');
                else
                  data.ashadow.hide();

                data.bshadow.css({opacity:-relX + 1});

                if (half) {
                  if (data.bshadow.parent()[0]!=data.wrapper[0]) {
                    data.bshadow.appendTo(data.wrapper);
                  }
                } else {
                  if (data.bshadow.parent()[0]!=data.fpage[0]) {
                    data.bshadow.appendTo(data.fpage);
                  }
                }
                /*data.bshadow.css({
                  backgroundColor: 'rgba(0,0,0,'+(0.1)+')'
                })*/
                gradient(data.bshadow, point2D(gradientX * 100, 0), point2D((-gradientX + 1)*100, 0),
                    [[0, 'rgba(0,0,0,0.3)'],[1, 'rgba(0,0,0,0)']],2);

              }

              break;
            case 'sheet':

              var that = this,
                  a = 0,
                  alpha = 0,
                  beta,
                  px,
                  gradientEndPointA,
                  gradientEndPointB,
                  gradientStartVal,
                  gradientSize,
                  gradientOpacity,
                  shadowVal,
                  mv = point2D(0, 0),
                  df = point2D(0, 0),
                  tr = point2D(0, 0),
                  folding = flipMethods._foldingPage.call(this),
                  tan = Math.tan(alpha),
                  ac = turnData.opts.acceleration,
                  h = data.wrapper.height(),
                  top = point.corner.substr(0, 1) == 't',
                  left = point.corner.substr(1, 1) == 'l',

                  compute = function() {

                    var rel = point2D(0, 0);
                    var middle = point2D(0, 0);

                    rel.x = (o.x) ? o.x - point.x : point.x;

                    if (!hasRot) {
                      rel.y = 0;
                    } else {
                      rel.y = (o.y) ? o.y - point.y : point.y;
                    }

                    middle.x = (left)? width - rel.x/2 : point.x + rel.x/2;
                    middle.y = rel.y/2;

                    var alpha =  A90-Math.atan2(rel.y, rel.x),
                        gamma = alpha - Math.atan2(middle.y, middle.x),
                        distance =  Math.max(0, Math.sin(gamma) * Math.sqrt(Math.pow(middle.x, 2) + Math.pow(middle.y, 2)));

                    a = deg(alpha);

                    tr = point2D(distance * Math.sin(alpha), distance * Math.cos(alpha));

                    if (alpha > A90) {
                      tr.x = tr.x + Math.abs(tr.y * rel.y/rel.x);
                      tr.y = 0;
                      if (Math.round(tr.x*Math.tan(PI-alpha)) < height) {
                        point.y = Math.sqrt(Math.pow(height, 2)+2 * middle.x * rel.x);
                        if (top) point.y =  height - point.y;
                        return compute();
                      }
                    }

                    if (alpha>A90) {
                      var beta = PI-alpha, dd = h - height/Math.sin(beta);
                      mv = point2D(Math.round(dd*Math.cos(beta)), Math.round(dd*Math.sin(beta)));
                      if (left) mv.x = - mv.x;
                      if (top) mv.y = - mv.y;
                    }

                    px = Math.round(tr.y/Math.tan(alpha) + tr.x);

                    var side = width - px,
                        sideX = side*Math.cos(alpha*2),
                        sideY = side*Math.sin(alpha*2);
                    df = point2D(
                        Math.round((left ? side -sideX : px+sideX)),
                        Math.round((top) ? sideY : height - sideY));

                    // Gradients
                    if (turnData.opts.gradients) {

                      gradientSize = side*Math.sin(alpha);

                      var endingPoint = flipMethods._c2.call(that, point.corner),
                          far = Math.sqrt(Math.pow(endingPoint.x-point.x, 2)+Math.pow(endingPoint.y-point.y, 2))/width;

                      shadowVal = Math.sin(A90*((far>1) ? 2 - far : far));

                      gradientOpacity = Math.min(far, 1);


                      gradientStartVal = gradientSize>100 ? (gradientSize-100)/gradientSize : 0;

                      gradientEndPointA = point2D(
                          gradientSize*Math.sin(alpha)/width*100,
                          gradientSize*Math.cos(alpha)/height*100);


                      if (flipMethods._backGradient.call(that)) {

                        gradientEndPointB = point2D(
                            gradientSize*1.2*Math.sin(alpha)/width*100,
                            gradientSize*1.2*Math.cos(alpha)/height*100);

                        if (!left) gradientEndPointB.x = 100-gradientEndPointB.x;
                        if (!top) gradientEndPointB.y = 100-gradientEndPointB.y;

                      }

                    }

                    tr.x = Math.round(tr.x);
                    tr.y = Math.round(tr.y);

                    return true;
                  },

                  transform = function(tr, c, x, a) {

                    var f = ['0', 'auto'], mvW = (width-h)*x[0]/100, mvH = (height-h)*x[1]/100,
                        cssA = {left: f[c[0]], top: f[c[1]], right: f[c[2]], bottom: f[c[3]]},
                        cssB = {},
                        aliasingFk = (a!=90 && a!=-90) ? (left ? -1 : 1) : 0,
                        origin = x[0] + '% ' + x[1] + '%';

                    that.css(cssA).
                    transform(rotate(a) + translate(tr.x + aliasingFk, tr.y, ac), origin);

                    data.fpage.css(cssA).transform(
                        rotate(a) +
                        translate(tr.x + df.x - mv.x - width*x[0]/100, tr.y + df.y - mv.y - height*x[1]/100, ac) +
                        rotate((180/a - 2)*a),
                        origin);

                    data.wrapper.transform(translate(-tr.x + mvW-aliasingFk, -tr.y + mvH, ac) + rotate(-a), origin);

                    data.fwrapper.transform(translate(-tr.x + mv.x + mvW, -tr.y + mv.y + mvH, ac) + rotate(-a), origin);

                    if (turnData.opts.gradients) {

                      if (x[0])
                        gradientEndPointA.x = 100-gradientEndPointA.x;

                      if (x[1])
                        gradientEndPointA.y = (100-gradientEndPointA.y);

                      cssB['box-shadow'] = '0 0 20px rgba(0,0,0,'+(0.5*shadowVal)+')';
                      folding.css(cssB);

                      gradient(data.ashadow,
                          point2D(left?100:0, top?0:100),
                          point2D(gradientEndPointA.x, gradientEndPointA.y),
                          [[gradientStartVal, 'rgba(0,0,0,0)'],
                            [((1-gradientStartVal)*0.8)+gradientStartVal, 'rgba(0,0,0,'+(0.2*gradientOpacity)+')'],
                            [1, 'rgba(255,255,255,'+(0.2*gradientOpacity)+')']],
                          3,
                          alpha);

                      if (flipMethods._backGradient.call(that))
                        gradient(data.bshadow,
                            point2D(left?0:100, top?0:100),
                            point2D(gradientEndPointB.x, gradientEndPointB.y),
                            [[0.6, 'rgba(0,0,0,0)'],
                              [0.8, 'rgba(0,0,0,'+(0.3*gradientOpacity)+')'],
                              [1, 'rgba(0,0,0,0)']
                            ],
                            3);
                    }

                  };

              switch (point.corner) {
                case 'l' :


                  break;
                case 'r' :


                  break;
                case 'tl' :
                  point.x = Math.max(point.x, 1);
                  compute();
                  transform(tr, [1,0,0,1], [100, 0], a);
                  break;
                case 'tr' :
                  point.x = Math.min(point.x, width-1);
                  compute();
                  transform(point2D(-tr.x, tr.y), [0,0,0,1], [0, 0], -a);
                  break;
                case 'bl' :
                  point.x = Math.max(point.x, 1);
                  compute();
                  transform(point2D(tr.x, -tr.y), [1,1,0,0], [100, 100], -a);
                  break;
                case 'br' :
                  point.x = Math.min(point.x, width-1);
                  compute();
                  transform(point2D(-tr.x, -tr.y), [0,1,1,0], [0, 100], a);
                  break;
              }

              break;
          }

          data.point = point;

        },

        _moveFoldingPage: function(move) {

          var data = this.data().f;

          if (!data)
            return;

          var turn = data.opts.turn,
              turnData = turn.data(),
              place = turnData.pagePlace;

          if (move) {

            var nextPage = data.opts.next;

            if (place[nextPage]!=data.opts.page) {

              if (data.folding)
                flipMethods._moveFoldingPage.call(this, false);

              var folding = flipMethods._foldingPage.call(this);

              folding.appendTo(data.fpage);
              place[nextPage] = data.opts.page;
              data.folding = nextPage;
            }

            turn.turn('update');

          } else {

            if (data.folding) {

              if (turnData.pages[data.folding]) {

                // If we have flip available

                var flipData = turnData.pages[data.folding].data().f;

                turnData.pageObjs[data.folding].
                appendTo(flipData.wrapper);

              } else if (turnData.pageWrap[data.folding]) {

                // If we have the pageWrapper

                turnData.pageObjs[data.folding].
                appendTo(turnData.pageWrap[data.folding]);

              }

              if (data.folding in place) {
                place[data.folding] = data.folding;
              }

              delete data.folding;

            }
          }
        },

        _showFoldedPage: function(c, animate) {

          var folding = flipMethods._foldingPage.call(this),
              dd = this.data(),
              data = dd.f,
              visible = data.visible;

          if (folding) {

            if (!visible || !data.point || data.point.corner!=c.corner) {

              var corner = (
                  data.status=='hover' ||
                  data.status=='peel' ||
                  data.opts.turn.data().mouseAction) ?
                  c.corner : null;

              visible = false;

              if (trigger('start', this, [data.opts, corner])=='prevented')
                return false;

            }

            if (animate) {

              var that = this,
                  point = (data.point && data.point.corner==c.corner) ?
                      data.point : flipMethods._c.call(this, c.corner, 1);

              this.animatef({
                from: [point.x, point.y],
                to: [c.x, c.y],
                duration: 500,
                frame: function(v) {
                  c.x = Math.round(v[0]);
                  c.y = Math.round(v[1]);
                  flipMethods._fold.call(that, c);
                }
              });

            } else  {

              flipMethods._fold.call(this, c);

              if (dd.effect && !dd.effect.turning)
                this.animatef(false);

            }

            if (!visible) {

              switch(data.effect) {
                case 'hard':

                  data.visible = true;
                  flipMethods._moveFoldingPage.call(this, true);
                  data.fpage.show();
                  if (data.opts.shadows)
                    data.bshadow.show();

                  break;
                case 'sheet':

                  data.visible = true;
                  data.fparent.show().data().flips++;
                  flipMethods._moveFoldingPage.call(this, true);
                  data.fwrapper.show();
                  if (data.bshadow)
                    data.bshadow.show();

                  break;
              }

            }

            return true;

          }

          return false;
        },

        hide: function() {

          var data = this.data().f,
              turnData = data.opts.turn.data(),
              folding = flipMethods._foldingPage.call(this);

          switch (data.effect) {
            case 'hard':

              if (turnData.opts.gradients) {
                data.bshadowLoc = 0;
                data.bshadow.remove();
                data.ashadow.hide();
              }

              data.wrapper.transform('');
              data.fpage.hide();

              break;
            case 'sheet':

              if ((--data.fparent.data().flips)===0)
                data.fparent.hide();

              this.css({left: 0, top: 0, right: 'auto', bottom: 'auto'}).
              transform('');

              data.wrapper.transform('');

              data.fwrapper.hide();

              if (data.bshadow)
                data.bshadow.hide();

              folding.transform('');

              break;
          }

          data.visible = false;

          return this;
        },

        hideFoldedPage: function(animate) {

          var data = this.data().f;

          if (!data.point) return;

          var that = this,
              p1 = data.point,
              hide = function() {
                data.point = null;
                data.status = '';
                that.flip('hide');
                that.trigger('end', [data.opts, false]);
              };

          if (animate) {

            var p4 = flipMethods._c.call(this, p1.corner),
                top = (p1.corner.substr(0,1)=='t'),
                delta = (top) ? Math.min(0, p1.y-p4.y)/2 : Math.max(0, p1.y-p4.y)/2,
                p2 = point2D(p1.x, p1.y+delta),
                p3 = point2D(p4.x, p4.y-delta);

            this.animatef({
              from: 0,
              to: 1,
              frame: function(v) {
                var np = bezier(p1, p2, p3, p4, v);
                p1.x = np.x;
                p1.y = np.y;
                flipMethods._fold.call(that, p1);
              },
              complete: hide,
              duration: 800,
              hiding: true
            });

          } else {

            this.animatef(false);
            hide();

          }
        },

        turnPage: function(corner) {

          var that = this,
              data = this.data().f,
              turnData = data.opts.turn.data();

          corner = {corner: (data.corner) ?
                data.corner.corner :
                corner || flipMethods._cAllowed.call(this)[0]};

          var p1 = data.point ||
              flipMethods._c.call(this,
                  corner.corner,
                  (data.opts.turn) ? turnData.opts.elevation : 0),
              p4 = flipMethods._c2.call(this, corner.corner);

          this.trigger('flip').
          animatef({
            from: 0,
            to: 1,
            frame: function(v) {

              var np = bezier(p1, p1, p4, p4, v);
              corner.x = np.x;
              corner.y = np.y;
              flipMethods._showFoldedPage.call(that, corner);

            },
            complete: function() {

              that.trigger('end', [data.opts, true]);

            },
            duration: turnData.opts.duration,
            turning: true
          });

          data.corner = null;
        },

        moving: function() {

          return 'effect' in this.data();

        },

        isTurning: function() {

          return this.flip('moving') && this.data().effect.turning;

        },

        corner: function() {

          return this.data().f.corner;

        },

        _eventStart: function(e) {

          var data = this.data().f,
              turn = data.opts.turn;

          if (!data.corner && !data.disabled && !this.flip('isTurning') &&
              data.opts.page==turn.data().pagePlace[data.opts.page])
          {

            data.corner = flipMethods._isIArea.call(this, e);

            if (data.corner && flipMethods._foldingPage.call(this)) {

              this.trigger('pressed', [data.point]);
              flipMethods._showFoldedPage.call(this, data.corner);

              return false;

            } else
              data.corner = null;

          }

        },

        _eventMove: function(e) {

          var data = this.data().f;

          if (!data.disabled) {

            e = (isTouch) ? e.originalEvent.touches : [e];

            if (data.corner) {

              var pos = data.parent.offset();
              data.corner.x = e[0].pageX-pos.left;
              data.corner.y = e[0].pageY-pos.top;
              flipMethods._showFoldedPage.call(this, data.corner);

            } else if (data.hover && !this.data().effect && this.is(':visible')) {

              var point = flipMethods._isIArea.call(this, e[0]);

              if (point) {

                if ((data.effect=='sheet' && point.corner.length==2)  || data.effect=='hard') {
                  data.status = 'hover';
                  var origin = flipMethods._c.call(this, point.corner, data.opts.cornerSize/2);
                  point.x = origin.x;
                  point.y = origin.y;
                  flipMethods._showFoldedPage.call(this, point, true);
                }

              } else {

                if (data.status=='hover') {
                  data.status = '';
                  flipMethods.hideFoldedPage.call(this, true);
                }

              }

            }

          }

        },

        _eventEnd: function() {

          var data = this.data().f,
              corner = data.corner;

          if (!data.disabled && corner) {
            if (trigger('released', this, [data.point || corner])!='prevented') {
              flipMethods.hideFoldedPage.call(this, true);
            }
          }

          data.corner = null;

        },

        disable: function(disable) {

          flipMethods.setData.call(this, {'disabled': disable});
          return this;

        },

        hover: function(hover) {

          flipMethods.setData.call(this, {'hover': hover});
          return this;

        },

        peel: function (corner, animate) {

          var data = this.data().f;

          if (corner) {

            if ($.inArray(corner, corners.all)==-1)
              throw turnError('Corner '+corner+' is not permitted');

            if ($.inArray(corner, flipMethods._cAllowed.call(this))!=-1) {

              var point = flipMethods._c.call(this, corner, data.opts.cornerSize/2);

              data.status = 'peel';

              flipMethods._showFoldedPage.call(this,
                  {
                    corner: corner,
                    x: point.x,
                    y: point.y
                  }, animate);

            }


          } else {

            data.status = '';

            flipMethods.hideFoldedPage.call(this, animate);

          }

          return this;
        }
      };


// Processes classes

  function dec(that, methods, args) {

    if (!args[0] || typeof(args[0])=='object')
      return methods.init.apply(that, args);

    else if (methods[args[0]])
      return methods[args[0]].apply(that, Array.prototype.slice.call(args, 1));

    else
      throw turnError(args[0] + ' is not a method or property');

  }


// Attributes for a layer

  function divAtt(top, left, zIndex, overf) {

    return {'css': {
        position: 'absolute',
        top: top,
        left: left,
        'overflow': overf || 'hidden',
        zIndex: zIndex || 'auto'
      }
    };

  }

// Gets a 2D point from a bezier curve of four points

  function bezier(p1, p2, p3, p4, t) {

    var a = 1 - t,
        b = a * a * a,
        c = t * t * t;

    return point2D(Math.round(b*p1.x + 3*t*a*a*p2.x + 3*t*t*a*p3.x + c*p4.x),
        Math.round(b*p1.y + 3*t*a*a*p2.y + 3*t*t*a*p3.y + c*p4.y));

  }

// Converts an angle from degrees to radians

  function rad(degrees) {

    return degrees/180*PI;

  }

// Converts an angle from radians to degrees

  function deg(radians) {

    return radians/PI*180;

  }

// Gets a 2D point

  function point2D(x, y) {

    return {x: x, y: y};

  }

// Webkit 534.3 on Android wrongly repaints elements that use overflow:hidden + rotation

  function rotationAvailable() {
    var parts;

    if ((parts = /AppleWebkit\/([0-9\.]+)/i.exec(navigator.userAgent))) {
      var webkitVersion = parseFloat(parts[1]);
      return (webkitVersion>534.3);
    } else {
      return true;
    }
  }

// Returns the traslate value

  function translate(x, y, use3d) {

    return (has3d && use3d) ? ' translate3d(' + x + 'px,' + y + 'px, 0px) '
        : ' translate(' + x + 'px, ' + y + 'px) ';

  }

// Returns the rotation value

  function rotate(degrees) {

    return ' rotate(' + degrees + 'deg) ';

  }

// Checks if a property belongs to an object

  function has(property, object) {

    return Object.prototype.hasOwnProperty.call(object, property);

  }

// Gets the CSS3 vendor prefix

  function getPrefix() {

    var vendorPrefixes = ['Moz','Webkit','Khtml','O','ms'],
        len = vendorPrefixes.length,
        vendor = '';

    while (len--)
      if ((vendorPrefixes[len] + 'Transform') in document.body.style)
        vendor='-'+vendorPrefixes[len].toLowerCase()+'-';

    return vendor;

  }

// Detects the transitionEnd Event

  function getTransitionEnd() {

    var t,
        el = document.createElement('fakeelement'),
        transitions = {
          'transition':'transitionend',
          'OTransition':'oTransitionEnd',
          'MSTransition':'transitionend',
          'MozTransition':'transitionend',
          'WebkitTransition':'webkitTransitionEnd'
        };

    for (t in transitions) {
      if (el.style[t] !== undefined) {
        return transitions[t];
      }
    }
  }

// Gradients

  function gradient(obj, p0, p1, colors, numColors) {

    var j, cols = [];

    if (vendor=='-webkit-') {

      for (j = 0; j<numColors; j++)
        cols.push('color-stop('+colors[j][0]+', '+colors[j][1]+')');

      obj.css({'background-image':
            '-webkit-gradient(linear, '+
            p0.x+'% '+
            p0.y+'%,'+
            p1.x+'% '+
            p1.y+'%, '+
            cols.join(',') + ' )'});
    } else {

      p0 = {x:p0.x/100 * obj.width(), y:p0.y/100 * obj.height()};
      p1 = {x:p1.x/100 * obj.width(), y:p1.y/100 * obj.height()};

      var dx = p1.x-p0.x,
          dy = p1.y-p0.y,
          angle = Math.atan2(dy, dx),
          angle2 = angle - Math.PI/2,
          diagonal = Math.abs(obj.width()*Math.sin(angle2))+Math.abs(obj.height()*Math.cos(angle2)),
          gradientDiagonal = Math.sqrt(dy*dy + dx*dx),
          corner = point2D((p1.x<p0.x) ? obj.width() : 0, (p1.y<p0.y) ? obj.height() : 0),
          slope = Math.tan(angle),
          inverse = -1/slope,
          x = (inverse*corner.x - corner.y - slope*p0.x + p0.y)/(inverse-slope),
          c = {x: x, y: inverse*x - inverse*corner.x + corner.y},
          segA = (Math.sqrt( Math.pow(c.x-p0.x,2) + Math.pow(c.y-p0.y,2)));

      for (j = 0; j<numColors; j++)
        cols.push(' '+colors[j][1]+' '+((segA + gradientDiagonal*colors[j][0])*100/diagonal)+'%');

      obj.css({'background-image': vendor+'linear-gradient(' + (-angle) + 'rad,' + cols.join(',') + ')'});
    }
  }


// Triggers an event

  function trigger(eventName, context, args) {

    var event = $.Event(eventName);
    context.trigger(event, args);
    if (event.isDefaultPrevented())
      return 'prevented';
    else if (event.isPropagationStopped())
      return 'stopped';
    else
      return '';
  }

// JS Errors

  function turnError(message) {

    function TurnJsError(message) {
      this.name = "TurnJsError";
      this.message = message;
    }

    TurnJsError.prototype = new Error();
    TurnJsError.prototype.constructor = TurnJsError;
    return new TurnJsError(message);

  }

// Find the offset of an element ignoring its transformation

  function findPos(obj) {

    var offset = {top: 0, left: 0};

    do{
      offset.left += obj.offsetLeft;
      offset.top += obj.offsetTop;
    } while ((obj = obj.offsetParent));

    return offset;

  }

// Checks if there's hard page compatibility
// IE9 is the only browser that does not support hard pages

  function hasHardPage() {
    return (navigator.userAgent.indexOf('MSIE 9.0')==-1);
  }

// Request an animation

  window.requestAnim = (function() {
    return window.requestAnimationFrame ||
        window.webkitRequestAnimationFrame ||
        window.mozRequestAnimationFrame ||
        window.oRequestAnimationFrame ||
        window.msRequestAnimationFrame ||
        function(callback) {
          window.setTimeout(callback, 1000 / 60);
        };

  })();

// Extend $.fn

  $.extend($.fn, {

    flip: function() {
      return dec($(this[0]), flipMethods, arguments);
    },

    turn: function() {
      return dec($(this[0]), turnMethods, arguments);
    },

    transform: function(transform, origin) {

      var properties = {};

      if (origin)
        properties[vendor+'transform-origin'] = origin;

      properties[vendor+'transform'] = transform;

      return this.css(properties);

    },

    animatef: function(point) {

      var data = this.data();

      if (data.effect)
        data.effect.stop();

      if (point) {

        if (!point.to.length) point.to = [point.to];
        if (!point.from.length) point.from = [point.from];

        var diff = [],
            len = point.to.length,
            animating = true,
            that = this,
            time = (new Date()).getTime(),
            frame = function() {

              if (!data.effect || !animating)
                return;

              var v = [],
                  timeDiff = Math.min(point.duration, (new Date()).getTime() - time);

              for (var i = 0; i < len; i++)
                v.push(data.effect.easing(1, timeDiff, point.from[i], diff[i], point.duration));

              point.frame((len==1) ? v[0] : v);

              if (timeDiff==point.duration) {
                delete data['effect'];
                that.data(data);
                if (point.complete)
                  point.complete();
              } else {
                window.requestAnim(frame);
              }
            };

        for (var i = 0; i < len; i++)
          diff.push(point.to[i] - point.from[i]);

        data.effect = $.extend({
          stop: function() {
            animating = false;
          },
          easing: function (x, t, b, c, data) {
            return c * Math.sqrt(1 - (t=t/data-1)*t) + b;
          }
        }, point);

        this.data(data);

        frame();

      } else {

        delete data['effect'];

      }
    }
  });

// Export some globals

  $.isTouch = isTouch;
  $.mouseEvents = mouseEvents;
  $.cssPrefix = getPrefix;
  $.cssTransitionEnd = getTransitionEnd;
  $.findPos = findPos;

})(jQuery);
